/*
 * Interface.cpp
 *
 *  Created on: 5 déc. 2009
 *      Author: math
 */


#include "Interface.h"

#include <wx/menu.h>
#include <wx/msgdlg.h>
#include "wx/sizer.h"
#include <wx/panel.h>
#include "glCanvas.h"

#include "liblut/gui/wx/LutWxPanelView.h"


LutEditorMainFrame::LutEditorMainFrame(const wxString& title,
                               const wxPoint& pos, const wxSize& size)
: wxFrame((wxFrame *)NULL, -1, title, pos, size)
  {
    //********** Panel - GUI design
    // aui manager
    m_mgr.SetManagedWindow(this);
    Show(true);
    //global sizer
    //wxPanel *globalPanel = new wxPanel (this , -1);
    //wxBoxSizer *globalsizer = new wxBoxSizer( wxHORIZONTAL );

     //lutWxPanel
     LutWxPanelView* lut_panel=new LutWxPanelView(this);

     //openGL panel
     wxPanel* gl_panel=new wxPanel(this,-1);
     wxBoxSizer* glsceneSizer = new wxBoxSizer(wxVERTICAL);
     wxSize glsize=wxSize(300,400);
     glCanvas* gl_canvas = new glCanvas(gl_panel, -1,wxDefaultPosition, glsize);
     glsceneSizer->Add(gl_canvas, 1, wxALL | wxEXPAND, 5);
     gl_panel->SetSizer(glsceneSizer);
     gl_panel->Layout();
     glsceneSizer->Fit(gl_panel);

     m_mgr.AddPane(gl_panel, wxCENTER, wxT("Scene"));
     m_mgr.AddPane(lut_panel, wxRIGHT, wxT("LUT"));

     //
     //globalsizer->Add(lut_panel, 0, wxALL | wxEXPAND, 5);
     //globalsizer->Add(gl_panel, 1, wxALL | wxEXPAND, 5);
     //globalPanel->SetSizer( globalsizer );
     //globalsizer->Fit(globalPanel);


     CreateMenu();
     Layout();
     SetStatusText( _T("Matis - IGN") );
     m_mgr.Update();

 }

void LutEditorMainFrame::CreateMenu()
{

     m_menuBar = new wxMenuBar;

    wxMenu *menuFile = new wxMenu;

    menuFile->Append( ID_OpenALS, _T("&Open ALS File"));
    menuFile->Append( ID_About, _T("&About...") );
    menuFile->AppendSeparator();
    menuFile->Append( ID_Quit, _T("&Exit") );

    wxMenu *menuLut = new wxMenu;

   // menuFile->Append( ID_IMPORT_LUT, _T("&Import...") );
   // menuFile->AppendSeparator();

   // wxMenu *sousMenu = new wxMenu;
   // sousMenu->Append(ID_EXPORT_IMAGE, _T("&Image"));
   // sousMenu->Append(ID_EXPORT_FICHIER_LUT, _T("Fichier &Lut"));

   // menuFile->AppendSubMenu(sousMenu, _T("E&xporter..."));
   // menuFile->AppendSeparator();

    m_menuBar->Append( menuFile, _T("&File") );
    m_menuBar->Append( menuLut, _T("&Lut") );

     SetMenuBar( m_menuBar );
}


void LutEditorMainFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
    //après clic sur about, ouverture d'un message box
    wxMessageBox(_T("This is a wxWidgets Hello world sample"),
            _T("About"), wxOK | wxICON_INFORMATION, this);
}

void LutEditorMainFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
    //fermer la fenêtre
    Close(TRUE);
}

void LutEditorMainFrame::OnInit()
{

}

    //sizer global qui contient tous les autres sizers
     //gl_canvas->SetCurrent();
     //gl_canvas->SwapBuffers();
   /* wxBoxSizer *globalsizer = new wxBoxSizer( wxHORIZONTAL );
    */


//    wxBoxSizer *vert1 = new wxBoxSizer( wxVERTICAL );
//    globalsizer->Add(vert1,
//                        0,
//                        wxALIGN_LEFT |wxADJUST_MINSIZE |wxLEFT |wxRIGHT ,
//                        20);
//
//    wxBoxSizer *vert3 = new wxBoxSizer( wxVERTICAL );
//    vert1->Add(vert3,
//                0,
//                wxALIGN_LEFT|wxADJUST_MINSIZE );
//
//    wxBoxSizer *boutonZone1_sizer = new wxBoxSizer( wxHORIZONTAL );

    //on ne peut saisir que des chiffres
//    wxTextValidator validator(wxFILTER_NUMERIC);

    //choix du type d'interpolation :static texte et une liste déroulante
//    wxStaticText *choixInterp = new wxStaticText(this,
//                                            -1,
//                                   _T("Choisir le type d'interpolation"),
//                                        wxDefaultPosition,
//                                                wxSize(210,25),
//                                                0,
//                                                _T("choixinterp"));
//    boutonZone1_sizer->Add(choixInterp,
//                            1,
//                            wxALIGN_LEFT | wxEXPAND |
//                            wxTOP|wxBOTTOM,
//                            5 );
//    wxString tab_choixinterp[2]={ _T("Interpolation exacte"),
//            _T("Interpolation lineaire")};
//    choixInterpolation = new wxComboBox( this,
//                                        ID_INTERPOLATION,
//                                        _T(""),
//                                        wxDefaultPosition,
//                                        wxSize(100, 25),
//                                        2,
//                                        tab_choixinterp,
//                                        wxCB_DROPDOWN,
//                                        wxDefaultValidator,
//                                        _T("choixInterpolation"));
    //bouton ajoutés aux sizers
//    boutonZone1_sizer->Add(choixInterpolation,
//                            1,
//                            wxALIGN_CENTER | wxEXPAND |
//                            wxTOP|wxBOTTOM,
//                            5 );
//    vert3->Add(boutonZone1_sizer,
//                0,
//                wxALIGN_LEFT |wxADJUST_MINSIZE );

    //module de saisie automatique des bornes: static text
//    wxBoxSizer *boutonZone2_sizer = new wxBoxSizer( wxHORIZONTAL );
//    wxStaticText *textSaisieAutoBornes = new wxStaticText(this,
//                                                -1,
//                            _T("Saisie automatique des bornes"),
//                              wxDefaultPosition,
//                                                        wxSize(230,24),
//                                                        0,
//                                                        _T("saisieAuto"));
//    boutonZone2_sizer->Add(textSaisieAutoBornes,
//                            1,
//                            wxALIGN_LEFT | wxEXPAND |
//                            wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                            5 );
//    vert3->Add(boutonZone2_sizer,
//                0,
//                wxALIGN_LEFT |wxADJUST_MINSIZE );
//
//    wxBoxSizer *boutonZone3_sizer = new wxBoxSizer( wxHORIZONTAL );
    //saisie de la valeur de la borne minimale: statictext + textctrl
//    wxStaticText *borneMin = new wxStaticText(this,
//                                                -1,
//                                                _T("Borne minimale : "),
//                                                wxDefaultPosition,
//                                                wxSize(210,25),
//                                                0,
//                                                _T("borneMin"));
//    boutonZone3_sizer->Add(borneMin,
//                            1,
//                            wxALIGN_LEFT | wxEXPAND |
//                            wxTOP|wxBOTTOM,
//                            5 );
//    borneMinValeur = new wxTextCtrl(this,
//                                    ID_BORNE_MIN,
//                                    _T(""),
//                                    wxDefaultPosition,
//                                    wxSize(70,25),
//                                    wxTE_PROCESS_ENTER,
//                                    validator,
//                                    _T("borneMinValeur"));
//    boutonZone3_sizer->Add(borneMinValeur,
//                            1,
//                            wxALIGN_RIGHT |
//                            wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                            5 );
//    vert3->Add(boutonZone3_sizer,
//                0,
//                wxALIGN_LEFT |wxADJUST_MINSIZE );
//
//    wxBoxSizer *boutonZone4_sizer = new wxBoxSizer( wxHORIZONTAL );
    //saisie de la valeur de la borne maximale :statictext + textctrl
//    wxStaticText *borneMax = new wxStaticText(this,
//                                                -1,
//                                                _T("Borne maximale : "),
//                                                wxDefaultPosition,
//                                                wxSize(210,25),
//                                                0,
//                                                _T("borneMax"));
//    boutonZone4_sizer->Add(borneMax,
//                            1,
//                            wxALIGN_LEFT | wxEXPAND |
//                            wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                            5 );
//    borneMaxValeur = new wxTextCtrl(this,
//                                    ID_BORNE_MAX,
//                                    _T(""),
//                                    wxDefaultPosition,
//                                    wxSize(70,23),
//                                    wxTE_PROCESS_ENTER,
//                                    validator,
//                                    _T("borneMaxValeur"));
//    boutonZone4_sizer->Add(borneMaxValeur,
//                            1,
//                            wxALIGN_CENTER | wxEXPAND |
//                            wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                            5 );
//    vert3->Add(boutonZone4_sizer,
//                0,
//                wxALIGN_LEFT|wxADJUST_MINSIZE );
//
//    wxBoxSizer *boutonZone5_sizer = new wxBoxSizer( wxHORIZONTAL );
    //choix du nombre d'intervalles qui seront définis : statictext+ combobox
//    wxStaticText *nbIntervalles = new wxStaticText(this,
//                                   -1,
//                                  _T("Nombre d'intervalles Ã  dÃ©finir : "),
//                                   wxDefaultPosition,
//                                   wxSize(210,30),
//                                   0,
//                                  _T("nbIntervalles"));
//    boutonZone5_sizer->Add(nbIntervalles,
//                            1,
//                            wxALIGN_LEFT | wxEXPAND |
//                            wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                            5 );
//    wxString tab_nbintervalle[9]={_T("1"),
//                                    _T("2"),
//                                    _T("3"),
//                                    _T("4"),
//                                    _T("5"),
//                                    _T("6"),
//                                    _T("7"),
//                                    _T("8"),
//                                    _T("9")};
//    choixNbIntervalle = new wxComboBox( this,
//                                        ID_NB_INTERVALLE,
//                                        _T(""),
//                                        wxDefaultPosition,
//                                        wxSize(90, 25),
//                                        9,
//                                        tab_nbintervalle,
//                                        wxCB_DROPDOWN,
//                                        wxDefaultValidator,
//                                        _T("nbintervalle"));
//    choixNbIntervalle->SetValue(_T("1"));
//    boutonZone5_sizer->Add(choixNbIntervalle,
//                            1,
//                            wxALIGN_RIGHT | wxEXPAND |
//                            wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                            5 );
//    vert3->Add(boutonZone5_sizer,
//                0,
//                wxALIGN_LEFT|wxADJUST_MINSIZE );
//
//    wxBoxSizer *boutonZone6_sizer = new wxBoxSizer( wxHORIZONTAL );
    //bouton du lancement du calcul
//    wxButton *boutonCalcul = new wxButton(this,
//                                            ID_CALCUL,
//                                            _T("Calcul des intervalles"),
//                                            wxDefaultPosition,
//                                            wxSize(160,25),
//                                            0,
//                                            wxDefaultValidator,
//                                            _T("calcul"));
//    boutonZone6_sizer->Add(boutonCalcul,
//                            1,
//                            wxALIGN_RIGHT | wxEXPAND |
//                            wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                            10 );
//    vert3->Add(boutonZone6_sizer,
//                0,
//                wxALIGN_RIGHT |wxADJUST_MINSIZE);
//
//    wxBoxSizer *boutonZone7_sizer = new wxBoxSizer( wxHORIZONTAL );
// choix du systeme de définition des couleurs grâce à une liste déroulante:
// statictext+combobox
//    wxStaticText *textSystemeCouleur = new wxStaticText(this,
//                                      -1,
//                                     _T("Systême de couleur"),
//                                     wxDefaultPosition,
//                                     wxSize(210,25),
//                                     0,
//                                    _T("systeme"));
//    boutonZone7_sizer->Add(textSystemeCouleur,
//                            1,
//                            wxALIGN_LEFT | wxEXPAND |
//                            wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                            5 );
//
//    wxString tab_systCouleur[2]={_T("RVB"),_T("TSL")};
//    choixSystemeCouleur = new wxComboBox( this,
//                                            ID_COMBO,
//                                            _T(""),
//                                            wxDefaultPosition,
//                                            wxSize(90, 25),
//                                            2,
//                                            tab_systCouleur,
//                                            wxCB_DROPDOWN,
//                                            wxDefaultValidator,
//                                            _T("combo"));
//    choixSystemeCouleur->SetValue(_T("RVB"));
//    boutonZone7_sizer->Add(choixSystemeCouleur,
//                            1,
//                            wxALIGN_CENTER | wxEXPAND |
//                            wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                            5 );
//    vert3->Add(boutonZone7_sizer,
//                0,
//                wxALIGN_LEFT );

    //définition des 3 boutons de manipulation du tableau:
    //"ajouter un élément"
//    wxBoxSizer *horz13 = new wxBoxSizer( wxHORIZONTAL );
//    vert1->Add(horz13,
//                0,
//                wxALIGN_CENTER|wxADJUST_MINSIZE );
//
//    wxBoxSizer *vert6 = new wxBoxSizer( wxVERTICAL );
//    horz13->Add(vert6,
//                    0,
//                    wxALIGN_LEFT |wxADJUST_MINSIZE);
//    ajout = new wxButton(this,
//                            ID_AJOUT,
//                            _T("+"),
//                            wxDefaultPosition,
//                            wxSize(37,37),
//                            0,
//                            wxDefaultValidator,
//                            _T("ajout"));
//    ajout->SetToolTip( _T("Ajouter une borne") );
//    vert6->Add(ajout,
//                1,
//                wxALIGN_LEFT|wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                5 );
    //"suppimer un élément"
//    supprimer = new wxButton(this,
//                                ID_SUPPR,
//                                _T("-"),
//                                wxDefaultPosition,
//                                wxSize(37,37),
//                                0,
//                                wxDefaultValidator,
//                                _T("Suppr"));
//    supprimer->SetToolTip( _T("Supprimer la (les) bornes cochée(s)") );
//    vert6->Add(supprimer,
//                1,
//                wxALIGN_LEFT|wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                5 );
    //"trier les éléments"
//  wxBitmap bitmap = wxBitmap(_T("../data/rcs/bouton_ajout2.bmp"),
//            wxBITMAP_TYPE_BMP);
//    tri =new wxBitmapButton(this,
//                            ID_TRI,
//                            bitmap,
//                            wxDefaultPosition);
//    tri->SetToolTip( _T("Trier les bornes par ordre croissant") );
//    vert6->Add(tri,
//                1,
//                wxALIGN_LEFT|wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                5 );
//
//    wxBoxSizer *vert8 = new wxBoxSizer( wxVERTICAL );
//    horz13->Add(vert8,
//                0,
//                wxALIGN_RIGHT |wxADJUST_MINSIZE);
    //les lignes seront stockées dans une fenetre avec une scroll bar
//    scrolledwin = new wxScrolledWindow(this,
//                                            wxID_ANY,
//                                            wxDefaultPosition,
//                                            wxSize(200,160),
//                                            wxVSCROLL);
//    vert8->Add( scrolledwin ,
//                0,
//                wxALIGN_RIGHT);
//    vert7 = new wxBoxSizer( wxVERTICAL );
//    vert7->SetMinSize(250,160);
//    scrolledwin->SetSizer(vert7);
//    scrolledwin->SetScrollbars(0, 100, 1, 80);
//    vert7->SetSizeHints(scrolledwin);
//    ViderLigne();
//    ViderIntervalleLut();
    //dessin des 2 lignes qui permettront de définir les bornes et les couleurs
//    CreateLigne(2,vert7,0);
    //+connection des boutons aux évènements associés
//    Connect( ID_TEXTE_CHANGE,
//            ID_TEXTE_CHANGE2,
//            wxEVT_COMMAND_TEXT_ENTER,
//            wxCommandEventHandler(MyFrame::OnTextChange ));
//
//    Connect( ID_CHOIXCOULEUR,
//            ID_CHOIXCOULEUR2,
//            wxEVT_COMMAND_BUTTON_CLICKED,
//            wxCommandEventHandler(MyFrame::OnButtonClic ));
//
//    wxBoxSizer *vert5 = new wxBoxSizer( wxVERTICAL );
//    vert1->Add(vert5,
//                1,
//                wxALIGN_LEFT|wxADJUST_MINSIZE );
//
//    wxBoxSizer *horz9 = new wxBoxSizer( wxHORIZONTAL );
//    vert5->Add(horz9,
//                1,
//                wxALIGN_LEFT |wxADJUST_MINSIZE);
    //choix de la transparence
//    wxStaticText *Choixtransparence = new wxStaticText(this,
//                                                        -1,
//                                                        _T("Transparence"),
//                                                        wxDefaultPosition,
//                                                        wxSize(150,25),
//                                                        0,
//                                                        _T("transparence"));
//    horz9->Add(Choixtransparence,
//                1,
//                wxALIGN_LEFT|
//                wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                15 );

    //le slider permettant de choisir la transparence
//    transparence = new wxSlider( this,
//                                ID_TRANSPARENCE,
//                                0,
//                                0,
//                                100,
//                                wxDefaultPosition,
//                                wxSize(155,wxDefaultCoord),
//                                wxSL_AUTOTICKS | wxSL_LABELS);
//    transparence->SetValue(100);
//    horz9->Add(transparence,
//                1,
//                wxALIGN_RIGHT|
//                wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                5 );
//
//    wxBoxSizer *horz10 = new wxBoxSizer( wxHORIZONTAL );
//    vert5->Add(horz10,
//                0,
//                wxALIGN_RIGHT |wxADJUST_MINSIZE);
    //le bouton appliquer qui permettra de dessiner une image
    // contenant le dégradé
//    wxButton *boutonAppliquer = new wxButton(this,
//                                            ID_APPLIQUER,
//                                            _T("Appliquer"),
//                                            wxDefaultPosition,
//                                            wxSize(160,27),
//                                            0,
//                                            wxDefaultValidator,
//                                            _T("appliquer"));
//    horz10->Add(boutonAppliquer,
//                1,
//                wxALIGN_RIGHT|
//                wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                5 );
//
//    horz11 = new wxBoxSizer( wxHORIZONTAL );
//    vert5->Add(horz11,
//                0,
//                wxALIGN_RIGHT );
/*	wxBoxSizer *horz11supplementaire = new wxBoxSizer( wxHORIZONTAL );
    horz11->Add(horz11supplementaire,
                0,
                wxALIGN_RIGHT );*/
    //définition de l'image qui contiendra le dégradé + affichage
//    image = new wxImage(256,60);
//    image->InitAlpha();
//    image->AddHandler(new wxPNGHandler);
//    std::cout<<"transp verif "<<(int) image->GetAlpha(45,45)<<std::endl;
//    AffichageImage();
//    image_ctrl = new wxStaticBitmap(this,
//                                    wxID_ANY,
//                                    wxBitmap(*image),
//                                    wxDefaultPosition,
//                                    wxSize(256,60));
//    horz11->Add(image_ctrl,
//                0,
//                wxALIGN_RIGHT |
//                wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//                5 );
//
//    wxBoxSizer *horz12 = new wxBoxSizer( wxHORIZONTAL );
//    vert5->Add(horz12,
//            0,
//            wxALIGN_RIGHT |wxADJUST_MINSIZE);
    //les 2 boutons annuler et visualisation de la lut sur un nuage de point
//    annuler = new wxButton(this,
//            ID_ANNULER,
//            _T("Annuler"),
//            wxDefaultPosition,
//            wxSize(100,27),
//            0,
//            wxDefaultValidator,
//            _T("annuler"));
//    horz12->Add(annuler,
//            0,
//            wxEXPAND |
//            wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//            5 );
//    visualiserLUT = new wxButton(this,
//            ID_VISUALISER_LUT,
//            _T("Visualiser la Lut"),
//            wxDefaultPosition,
//            wxSize(160,27),
//            0,
//            wxDefaultValidator,
//            _T("visualiserLUT"));
//    horz12->Add(visualiserLUT,
//            0,
//            wxEXPAND |
//            wxTOP|wxBOTTOM|wxADJUST_MINSIZE,
//            5 );
//
//    globalsizer->SetSizeHints(this); //minimiser la taille de la fenetre
//  }

/*--------------------------------------------------------------------------*/
/*  Initialisation de l'image affichée lors de la création de l'interface   */
/*--------------------------------------------------------------------------*/
/* Description : en entrée :                                                */
/*              en sortie : l'image avec un fond blanc                      */
/*--------------------------------------------------------------------------*/
//void MyFrame::AffichageImage(){
//    for(int y=0;y<60;y++)
//    {
//        for(int x=0;x<256;x++)
//        {
//            image->SetRGB(x,y,255,255,255);
//        }
//    }
//}

/*---------------------------------------------------------------------------*/
/*Clic sur le bouton appliquer:appel de la fonction ImageRemplissageCouleur()*/
/*---------------------------------------------------------------------------*/
/* Description : en entrée :                                                 */
/*               en sortie : verification que l'utilisateur a correctement   */
/*               rempli l'interface                                          */
/*               appel de la fonction ImageRemplissageCouleur()              */
/*---------------------------------------------------------------------------*/
//void MyFrame::Appliquer(wxCommandEvent& event){
//    std::cout<<"appliquer"<<std::endl;
//    int d = image->GetAlpha(45,45);
//    std::cout<<"transparence  "<<d<<std::endl;
//    if(typeInterpolation == -1)
//    {
//        wxMessageBox(_T("Il faut choisir le type d'interpolation"),
//                _T("About"), wxOK | wxICON_INFORMATION, this);
//    }
//    else if(intervalle_lut.size() <1)
//    {
//        wxMessageBox(_T("Il faut au moins deux bornes
//                 pour pouvoir calculer l'interpolation"),
//                _T("About"), wxOK | wxICON_INFORMATION, this);
//    }
//    else
//    {
//        ImageRemplissageCouleur();
//        image_ctrl->Destroy();
//        //horz11->Hide((size_t) 0);
//        horz11->Layout();
//        //wxBoxSizer *horz11supplementaire = new wxBoxSizer(wxHORIZONTAL);
//        /*horz11->Add(horz11supplementaire,
//                1,
//                wxALIGN_LEFT |wxADJUST_MINSIZE);*/
//        image_ctrl = new wxStaticBitmap(this,
//                wxID_ANY,
//                wxBitmap(*image),
//                wxDefaultPosition,
//                wxSize(256,60));
//
//        horz11->Add(image_ctrl,
//                    0,
//                    wxEXPAND |
//                    wxALL|wxADJUST_MINSIZE,
//                    1 );
//        horz11->Layout();
//    }
//}

/*---------------------------------------------------------------------------*/
/*        Fonction appelée par Appliquer()                                   */
/*---------------------------------------------------------------------------*/
/* Description : en entrée :                                                 */
/*               en sortie : 2 cas:                                          */
/*                 * interpolation exacte                                    */
/*                 * interpolation	linéaire                                 */
/*                 dans les 2 cas: appel de CadrageIntervalle()              */
/*                 calcul de l'interpolation                                 */
/*                 remplissage de l'image (255*60 px)                        */
/*---------------------------------------------------------------------------*/
//void MyFrame::ImageRemplissageCouleur()
//{
//    //il faut vider le vecteur intervalle_image
//    //qui a été initialisé si une image a déjà été soit enregistrée soit
//    // affichée suite à "Appliquer")
//    if(intervalle_image.size() != 0)
//    {
//        intervalle_image.clear();
//    }
//    CadrageIntervalle();
//    int Couleur1,Couleur2,Couleur3;
//    switch (typeInterpolation)
//    {
//        case 0: //interpolation exacte
//        {
//            InterpolationExacte *interpolation = new InterpolationExacte();
//            //on décrit toute les bornes caractéristiques de la lut
//            for(int C13 = 0;C13<intervalle_image.size()-1;C13++)
//            {
//                // on décrit tous les entiers compris entre les
//                // bornes caractéristiques de la lut
//                //pour remplir tous les pixeles appartenant à [0;255]
//                for(int C10 = 0;
//                  C10<(int)(intervalle_image[C13+1]->b-intervalle_image[C13]->b)+1;
//                  C10++)
//                {
//                    interpolation->CalculInterpolation(systemeCouleur,
//                                                intervalle_image[C13],
//                                                intervalle_image[C13+1],
//                                         (int)intervalle_image[C13]->b+C10);
//                    //si les couleurs sont en TSL, on les transforme en RVB
//                    //parce qu'on ne peut écrire une couleur
//                    // dans une image qu'en RVB
//                    if(systemeCouleur == 1)
//                    {	Couleur *CouleurTSL = new Couleur(interpolation->i_R1,
//                                                        interpolation->i_V1,
//                                                        interpolation->i_B1,
//                                                        systemeCouleur);
//                        CouleurTSL->TSL2RVB();
//                        Couleur1 = CouleurTSL->C1;
//                        Couleur2 = CouleurTSL->C2;
//                        Couleur3 = CouleurTSL->C3;
//                    }
//                    else
//                    {
//                        Couleur1 = interpolation->i_R1;
//                        Couleur2 = interpolation->i_V1;
//                        Couleur3 = interpolation->i_B1;
//                    }
//                    //ecriture de la couleur dans l'image (même couleur
//                    //sur toute la hauteur de l'image)
//                    for(int y2=0;y2<60;y2++)
//                    {
//                        image->SetRGB((int)(intervalle_image[C13]->b)+C10,
//                                        y2,
//                                        (unsigned char)Couleur1,
//                                        (unsigned char)Couleur2,
//                                        (unsigned char)Couleur3);
///*                    image->SetAlpha((int)(intervalle_image[C13]->b)+C10,
//                                        y2,
//                                        alpha);*/
//                    }
//                }
//
//            }
//        }
//        break;
//        case 1: //interpolation linéaire
//        {
//            InterpolationLineaire *interpolation = new InterpolationLineaire();
//            //on décrit toute les bornes caractéristiques de la lut
//            for(int C13 = 0;C13<intervalle_image.size()-1;C13++)
//            {
//                //on décrit tous les entiers compris entre les bornes
//                //caractéristiques de la lut pour remplir tous les pixels
//                // appartenant à [0;255]
//            for(int C10 = 0;
//             C10<(int)(intervalle_image[C13+1]->b-intervalle_image[C13]->b)+1;
//              C10++)
//                {
//                  double ti =
//                   C10/(intervalle_image[C13+1]->b-intervalle_image[C13]->b);
//                  interpolation->CalculInterpolation(systemeCouleur,
//                                                    intervalle_image[C13],
//                                                    intervalle_image[C13+1],
//                                                    ti);
//                  //si les couleurs sont en TSL, on les transforme en RVB
//                  //parce qu'on ne peut écrire une couleur dans une
//                  //image qu'en RVB
//                  if(systemeCouleur == 1)
//                  {
//                    Couleur *CouleurTSLLin = new Couleur(interpolation->i_R1,
//                                                    interpolation->i_V1,
//                                                    interpolation->i_B1,
//                                                    systemeCouleur);
//                    CouleurTSLLin->TSL2RVB();
//                    Couleur1= CouleurTSLLin->C1;
//                    Couleur2= CouleurTSLLin->C2;
//                    Couleur3= CouleurTSLLin->C3;
//                    }
//                    else
//                    {
//                        Couleur1 = interpolation->i_R1;
//                        Couleur2 = interpolation->i_V1;
//                        Couleur3 = interpolation->i_B1;
//                    }
//                    //ecriture de la couleur dans l'image (même couleur
//                    //sur toute la hauteur de l'image)
//                    for(int y2=0;y2<60;y2++)
//                    {
//                        image->SetRGB((int)(intervalle_image[C13]->b)+C10,
//                                        y2,
//                                        (unsigned char)Couleur1,
//                                        (unsigned char)Couleur2,
//                                        (unsigned char)Couleur3);
//                          image->SetAlpha((int)(intervalle_image[C13]->b)+C10,
//                                        y2,
//                                        alpha);*/
//                    }
//                }
//            }
//        }
//        break;
//        default:
//            wxMessageBox(_T("Il faut choisir le type d'interpolation"),
//                    _T("About"), wxOK | wxICON_INFORMATION, this);
//        }
//    std::cout<<"sort de image remplissage couleur"<<std::endl;
//}

/*---------------------------------------------------------------------------*/
/*         Fonction appelée par ImageRemplissageCouleur()                    */
/*---------------------------------------------------------------------------*/
/* Description : en entrée :                                                 */
/*               en sortie : appel de FonstionTri                            */
/*                on adapte l'intervalle_lut dans l'intervalle[0;255]        */
/*                car cet intervalle est initialement saisi                  */
/*                dans l'intervalle spécifique à l'attribut                  */
/*---------------------------------------------------------------------------*/
//void MyFrame::CadrageIntervalle()
//{
//    //il faut que intervalle_lut ait été préalablement trié
//    FonctionTri();
//
//    //on adapte l'intervalle_lut dans l'intervalle[0;255],
//    //comme on veut conserver intervalle_lut non modifié,
//    //cette adaptation necessite que l'on travaille sur
//    //un intervalle "copie" (ie: intervalle_image)
//    for(int C9 = 0;C9<intervalle_lut.size();C9++)
//    {
//        Borne *Btemp = new Borne(intervalle_lut[C9]->b,
//                intervalle_lut[C9]->Coul.C1,
//                intervalle_lut[C9]->Coul.C2,
//                intervalle_lut[C9]->Coul.C3,
//                intervalle_lut[C9]->Coul.systCouleur);
//        intervalle_image.push_back(Btemp);
//    }
//    //on ne travaille plus que sur intervalle_image
//    //calcul des coefficients de la transformation lineaire
//    double bM = intervalle_image[intervalle_image.size()-1]->b;
//    double bm = intervalle_image[0]->b;
//    double a = 255/(bM-bm);
//    double c = -a*bm;
//    //on applique la transformation à chaque borne de la lut
//    for(int C11 = 0; C11<intervalle_image.size();C11++)
//    {
//        double btemp = a*intervalle_image[C11]->b + c;
//        intervalle_image[C11]->modifier_attr(btemp);
//    }
//}



/*--------------------------------------------------------------------------*/
/*                CreateLigne()                                             */
/*--------------------------------------------------------------------------*/
/* Description : en entrée :                                                */
/*               en sortie : fonction appelée lors de l'ajout d'une ligne   */
/*                      ou lors la création de l'interface                  */
/*                      crée un ligne (checkbox+zone de texte+ bouton)      */
/*                      les rajoute dans le scrolledwindow                  */
/*                      et remet à jour la scrolledwindow pour la scrollbar)*/
/*--------------------------------------------------------------------------*/
//void MyFrame::CreateLigne(int nombligne, wxBoxSizer *place, int debutID)
//{
//    std::cout<< "création de lignes"<<std::endl;
//    wxTextValidator validatorbis(wxFILTER_NUMERIC);
//    //création des zones de texte (une par ligne sur 2 lignes pour commencer)
//    for(int C1=0; C1<nombligne ; C1++)
//    {
//        wxBoxSizer *horztemp = new wxBoxSizer( wxHORIZONTAL );
//        //création des checkbox permettant de choisir les lignes à supprimer
//        wxCheckBox *checkboxtemp = new wxCheckBox(scrolledwin,
//                                         ID_CHECK_SUPPR+ debutID + C1,
//                                        _T(""),
//                                        wxDefaultPosition,
//                                        wxSize(10,10),
//                                        0,
//                                        wxDefaultValidator,
//                                       _T("checkBox"));
//        horztemp->Add(checkboxtemp,
//                        0,
//                        wxALIGN_LEFT |wxTOP|wxBOTTOM|wxRIGHT,
//                        15 );
//        checkbox_suppr.push_back(checkboxtemp);
//
//        //zone de texte permettant de saisir les valeur des bornes
//        wxTextCtrl *textetemp = new wxTextCtrl(scrolledwin,
//                                   ID_TEXTE_CHANGE+ debutID + C1,
//                                   _T("0"),
//                                   wxDefaultPosition,
//                                   wxSize(150,27),
//                                   wxTE_PROCESS_ENTER,
//                                   validatorbis,
//                                   _T("zdt1"));
//        textetemp->SetToolTip( _T("Saisir la valeur de l'attribut") );
//        horztemp->Add(textetemp,
//                        0,
//                        wxALIGN_LEFT |wxTOP|wxBOTTOM,
//                        7 );
//        zonetexte.push_back(textetemp);
//
//        //creation des boutons permettant de choisir les couleurs
//        wxButton *boutontemp = new wxButton(scrolledwin,
//                                    ID_CHOIXCOULEUR+ debutID + C1,
//                                    _T(""),
//                                    wxDefaultPosition,
//                                    wxSize(60,27),
//                                    0,
//                                    wxDefaultValidator,
//                                   _T("test"));
//        boutontemp->SetToolTip( _T("Cliquer pour choisir la couleur") );
//        horztemp->Add(boutontemp,
//                        0,
//                        wxALIGN_LEFT |wxTOP|wxBOTTOM,
//                        7 );
//        bouton.push_back(boutontemp);
//        place->Add(horztemp,
//                    0,
//                    wxALIGN_LEFT |wxADJUST_MINSIZE);
//    }
//    scrolledwin->FitInside();
//}
/*--------------------------------------------------------------------------*/
/*          Permet de supprimer toutes le lignes de l'interface             */
/*--------------------------------------------------------------------------*/
/* Description : en entrée :                                                */
/*              en sortie : plus aucune ligne dans l'interface              */
/* Explications : supprime successiveent:                                   */
/*                     * les boutons et vide le vecteur bouton              */
/*                     * les zones de texte et vide le vecteur zonetexte    */
/*                     * les checkbox et vide le vecteur checkbox_suppr     */
/*--------------------------------------------------------------------------*/
//void MyFrame::ViderLigne()
//{
//    if(bouton.size() != 0)
//    {
//        for (int C2 = 0; C2<bouton.size();C2++)
//        {
//            bouton[C2]->Destroy();
//            zonetexte[C2]->Destroy();
//            checkbox_suppr[C2]->Destroy();
//        }
//        zonetexte.clear();
//        bouton.clear();
//        checkbox_suppr.clear();
//    }
//}
/*---------------------------------------------------------------------------*/
/*     Permet de supprimer tous les elements contenus dans intervalle_lut    */
/*---------------------------------------------------------------------------*/
//void MyFrame::ViderIntervalleLut()
//{
//    intervalle_lut.clear();
//}

/*---------------------------------------------------------------------------*/
/*                  Permet de choisir la couleur                             */
/*---------------------------------------------------------------------------*/
/* Description : en entrée : clic sur un bouton                              */
/*              en sortie : le bouton avec en couleur de fond                */
/*              la couleur sélectionnée par l'utilisateur                    */
/* Explications :clic sur le bouton                                          */
/*              ouverture d'une dialog box                                   */
/*              enregistrement de la couleur saisie                          */
/*              cette couleur est placée comme couleur de fond du bouton     */
/*              cliqué                                                       */
/*---------------------------------------------------------------------------*/
//void MyFrame::OnButtonClic(wxCommandEvent& event)
//{
//    //récupération du l'identifiant du bouton cliqué
//    int id = event.GetId();
//
//    //l'identifiant du bouton cliqué dans le vecteur bouton
//    int numbouton=id-200;
//    int vert,rouge, bleu;
//    //initialisation des données envoyées à la boite de dialogue
//    MyData g_data;
//    g_data.m_systCouleur = systemeCouleur;
//    g_data.m_rouge_state = 125;
//    g_data.m_vert_state = 125;
//    g_data.m_bleu_state = 125;
//    g_data.m_teinte_state = 180;
//    g_data.m_saturation_state = 125;
//    g_data.m_luminance_state = 125;
//
//    //ouverture de la boite de dialogue permettant de choisir la couleur
//    ColorDialog *dialog = new ColorDialog
//                 (&g_data, this, wxT("Selectionner une couleur"));
//    dialog->Show(TRUE);
//    //choix d'une couleur
//    if ( dialog->ShowModal() == wxID_OK )
//    {
//    }
//    //si systeme de couleur: RVB
//    if(systemeCouleur == 0)
//    {
//        wxColour CouleurBouton((unsigned char)g_data.m_rouge_state,
//                                (unsigned char)g_data.m_vert_state,
//                                (unsigned char)g_data.m_bleu_state);
//
//        //affectation de la couleur choisie comme couleur
//        // de fond du bouton cliqué
//        bouton[numbouton]->SetBackgroundColour(CouleurBouton);
//        bouton[numbouton]->Refresh();
//        vert= (int)g_data.m_vert_state;
//        bleu= (int)g_data.m_bleu_state;
//        rouge= (int)g_data.m_rouge_state;
//    }
//    //si systeme de couleur : TSL
//    //il faut transformer les couleurs en RVB
//    // pour pouvoir les mettre comme couleur de fond des boutons
//    else if (systemeCouleur == 1)
//    {
//        Couleur *CouleurTSL = new Couleur(g_data.m_teinte_state,
//                                            g_data.m_saturation_state,
//                                            g_data.m_luminance_state,
//                                            systemeCouleur);
//        CouleurTSL->TSL2RVB();
//        wxColour CouleurBouton((unsigned char)CouleurTSL->C1,
//                                (unsigned char)CouleurTSL->C2,
//                                (unsigned char)CouleurTSL->C3);
//        //affectation de la couleur choisie comme fond du bouton cliqué
//        bouton[numbouton]->SetBackgroundColour(CouleurBouton);
//        bouton[numbouton]->Refresh();
//        rouge= (int)g_data.m_teinte_state;
//        vert= (int)g_data.m_saturation_state;
//        bleu= (int)g_data.m_luminance_state;
//    }
//    wxString valeurborne=zonetexte[numbouton]->GetValue();
//    double valeurborne_doubl;
//    if (valeurborne.ToDouble(&valeurborne_doubl))
//    {
//        int taille = intervalle_lut.size();
//        // si on a cré un nouveau bouton
//        //on crée un nouvel élément de lut (b = 0) et
//        //on lui affecte la couleur choisie
//        if(taille == 0 || numbouton > taille-1)
//        {
//            Borne *B1 = new Borne(rouge,vert,bleu, systemeCouleur);
//            intervalle_lut.push_back(B1);
//        }
//        //sinon on se contente de remplacer l'ancienne valeur
//        //de la couleur par la nouvelle
//        else
//        {
//          intervalle_lut[numbouton]->modifier_coul(rouge,
//                         vert,bleu, systemeCouleur);
//        }
//    }
//    else
//    {
//          std::cout<<"string to double error"<<std::endl;
//    }
//}


/*--------------------------------------------------------------------------*/
/*          Permet d'enregistrer la valeur saisie par l'utilisateur         */
/*--------------------------------------------------------------------------*/
/* Description : en entrée : la valeur saisie par l'utilisateur             */
/*               en sortie : le vecteur intervalle_lut mis à jour           */
/* Explications : récupère la valeur de l'attribut saisie par l'utilisateur:*/
/*                *si la borne existe déjà , modifie a valeur de l'attribut */
/*                    (mise à jour de la saisie)                            */
/*                *si la borne n'existe pas encore: crée un nouvelle borne  */
/*                    avec la valeur saisie et une couleur par défaut       */
/*--------------------------------------------------------------------------*/

//void MyFrame::OnTextChange(wxCommandEvent& event)
//{
//    int rouge = 0;
//    int vert = 0;
//    int bleu = 0;
////on recupère l'id de la zone de texte modifiée
//    int id_texte = event.GetId();
//    int numzone=id_texte-100;
//    wxString valeurborne=zonetexte[numzone]->GetValue();
//    double valeurborne_doubl;
//    if (valeurborne.ToDouble(&valeurborne_doubl))
//    {
//        int taille = intervalle_lut.size();
//        // si on a crée une nouvelle zone de texte
//        // on crée un nouvel élément de lut et on y stocke
//        //la valeur de la borne (couleur: 0,0,0)
//        if(taille == 0 || numzone > taille-1)
//        {
//            Borne *B1 = new Borne(valeurborne_doubl,
//               rouge,vert,bleu, systemeCouleur);
//            intervalle_lut.push_back(B1);
//        }
//        //sinon on remplace l'ancienne valeur de la borne par la nouvelle
//        else
//        {
//            intervalle_lut[numzone]->modifier_attr(valeurborne_doubl);
//        }
//        // on vérifie que le min et la max de la lut n'ont pas changé
//        VerifBorneMax(valeurborne_doubl);
//        VerifBorneMin(valeurborne_doubl);
//    }
//    else{
//        std::cout<<"string to double error"<<std::endl;
//    }
//}

/*--------------------------------------------------------------------------*/
/*                 Permet d'ajouter une ligne de saisie                     */
/*--------------------------------------------------------------------------*/
/* Description : en entrée : clic sur le bouton "ajout"                     */
/*               en sortie : dans l'interface: une nouvelle ligne           */
/* Explications : crée une ligne avec une checkbox, une zone de texte       */
/*                 et un bouton                                             */
/*--------------------------------------------------------------------------*/
//void MyFrame::Ajout(wxCommandEvent& event)
//{
//    //ajout d'une ligne (à la fin du tableau)
//    wxTextValidator validator(wxFILTER_NUMERIC);
//    int nbligne=bouton.size();
//    if(nbligne>10)
//    {
//    wxMessageBox(_T("On ne peut saisir qu'un nombre restreint de lignes 10"),
//           _T("About"), wxOK | wxICON_INFORMATION, this);
//    }
//    else{
//        CreateLigne(1,vert7,nbligne);
//        vert7->Layout();
//    }
//    //mise à jour du nombre d'intervalles
//    MAJNbIntervalle();
//}

/*--------------------------------------------------------------------------*/
/*                     Permet de supprimer une ligne                        */
/*--------------------------------------------------------------------------*/
/* Description :                                                            */
/*         en entrée : clic sur le boutont "supprimer"                      */
/*         en sortie : la ligne sélectionnée est supprimée de l'interface   */
/* Explications : récupère le numéro de la ligne à supprimer                */
/*           *supprime la ligne                                             */
/*           *supprime les données qui étaient contenues par la ligne       */
/*              (valeur de l'attribut+couleur)                              */
/*--------------------------------------------------------------------------*/
//void MyFrame::Suppr(wxCommandEvent& event)
//{
//    std::cout<<"suppr"<<std::endl;
//    std::cout<<"taille check  "<<checkbox_suppr.size()<<std::endl;
//    //il faut qu'au moins 1 check box ait été cochée
//    if(checkbox_suppr.size() == 0)
//    {
//        wxMessageBox(_T("Il n'y a pas de ligne à supprimer"),
//                _T("About"), wxOK | wxICON_INFORMATION, this);
//    }
//    else
//    {
//        std::cout<<"entre else 1"<<std::endl;
//        int nbcheckbox_cochees = 0;
//        //parcourt des checkboxs pour savoir quelle lignes devront
//        //être supprimées
//        for (int C4=0;C4<checkbox_suppr.size();C4 ++)
//        {
//          std::cout<<"entre for 1"<<std::endl;
//          //suppression de la ligne sélectionnées (ie: checkbox cochée)
//          //et mise à jour des tableaux contenant les boutons et les
//          //zones de texte
//          std::cout<<"cochée??  "<<checkbox_suppr[C4]->IsChecked()<<std::endl;
//            if (checkbox_suppr[C4]->IsChecked())
//            {
//                if(C4<intervalle_lut.size()){
//                    intervalle_lut.erase(intervalle_lut.begin() + C4);
//                }
//                checkbox_suppr.erase(checkbox_suppr.begin() + C4);
//                C4=C4-1;
//                nbcheckbox_cochees = nbcheckbox_cochees+1;
//            }
//        }
//        if(nbcheckbox_cochees == 0)
//        {
//            wxMessageBox(_T("Pour supprimer une ligne, il faut d'abord
//                  la sélectionner en cochant la check-box correspondante"),
//                    _T("About"), wxOK | wxICON_INFORMATION, this);
//        }
//        else
//        {
//            bouton.clear();
//            zonetexte.clear();
//            checkbox_suppr.clear();
//            scrolledwin->DestroyChildren();
//            //réaffichage des différents tableau d'éléments
//            //(et ajustement de la position des lignes)
//            CreateLigne(intervalle_lut.size(),vert7,0);
//            for(int C5=0;C5<intervalle_lut.size();C5++)
//            {
//                //si systeme de couleur: RVB
//                if(systemeCouleur == 0)
//                {
//                    wxColour CouleurBouton(intervalle_lut[C5]->Coul.C1,
//                                            intervalle_lut[C5]->Coul.C2,
//                                            intervalle_lut[C5]->Coul.C3);
//
//                    //affectation de la couleur choisie comme couleur
//                    //de fond du bouton cliqué
//                    bouton[C5]->SetBackgroundColour(CouleurBouton);
//                    bouton[C5]->Refresh();
//                }
//                //si systeme de couleur : TSL
//                //il faut transformer les couleurs en RVB
//                //pour pouvoir les mettre comme couleur de fond des boutons
//                else if (systemeCouleur == 1)
//                {
//                    Couleur *CouleurTSL = new Couleur(
//                                                 intervalle_lut[C5]->Coul.C1,
//                                                 intervalle_lut[C5]->Coul.C2,
//                                                 intervalle_lut[C5]->Coul.C3,
//                                                 systemeCouleur);
//                    CouleurTSL->TSL2RVB();
//                    wxColour CouleurBouton((unsigned char)CouleurTSL->C1,
//                                           (unsigned char)CouleurTSL->C2,
//                                           (unsigned char)CouleurTSL->C3);
//                    //affectation de la couleur choisie comme
//                    //fond du bouton cliqué
//                    bouton[C5]->SetBackgroundColour(CouleurBouton);
//                    bouton[C5]->Refresh();
//                }
//                wxString montexte;
//                montexte << intervalle_lut[C5]->b;
//                zonetexte[C5]->SetValue(montexte);
//                zonetexte[C5]->Refresh();
//            }
//        }
//    }
//    //mise a jour du nombre d'intervalles
//    MAJNbIntervalle();
//}

/*--------------------------------------------------------------------------*/
/* Met à jour le nombre d'intervalles dans la combobox "choixNbIntervalle"  */
/*--------------------------------------------------------------------------*/
//void MyFrame::MAJNbIntervalle()
//{
//    nbintervalle = bouton.size()-1;
//    wxString st_nbInter;
//    st_nbInter << nbintervalle;
//    // on ne peut pas avoir un npmbre d'intervalle négatif
//    if(nbintervalle < 0)
//    {
//        choixNbIntervalle->SetValue(_T("0"));
//    }
//    else
//    {
//        choixNbIntervalle->SetValue(st_nbInter);
//    }
//}
/*---------------------------------------------------------------------------*/
/*          Permet d'appeler le tri d'un vecteur                             */
/*---------------------------------------------------------------------------*/
/* Description : en entrée : clic sur le bouton "tri"                        */
/* Explications : après clic sur le bouton "tri",                            */
/*                lance le tri de intervalle_lut                             */
/*---------------------------------------------------------------------------*/
//void MyFrame::Tri(wxCommandEvent& event)
//{
//    std::cout<<"tri"<<std::endl;
//    //tri du vecteur en fonction de la valeur de la borne
//    //(utilisation de la relation d'ordre définie précédemment)
//    FonctionTri();
//}

/*---------------------------------------------------------------------------*/
/*       Permet de trier le vecteur selon la relation d'ordre définie        */
/*---------------------------------------------------------------------------*/
/* Description : en entrée : le vecteur de borne non trié                    */
/*              en sortie : le même vecteur trié                             */
/* Explications : prends le vecteur non trié                                 */
/*               le trie en fonction de la valeur de l'attribut (ie de b)   */
/*               renvoie le vecteur trié                                    */
/*---------------------------------------------------------------------------*/
//bool compareVecteurBis(Borne* A, Borne* B)
//{
//    return (A->b < B->b);
//}

//void MyFrame::FonctionTri()
//{
//    std::sort(intervalle_lut.begin(),intervalle_lut.end(),compareVecteurBis);
//    std::cout<<"passage du tri de  intervalle_lut"<<std::endl;
//    for(int C7=0; C7<bouton.size();C7++)
//    {
//        //si le systeme de couleurs est RVB
//        if(systemeCouleur == 0)
//        {
//            //C1=rouge,C2=vert,C3=bleu
//        wxColour couleurFond(
//                (unsigned char)(intervalle_lut[C7]->Coul.C1),
//                (unsigned char)(intervalle_lut[C7]->Coul.C2),
//                (unsigned char)(intervalle_lut[C7]->Coul.C3));
//        bouton[C7]->SetBackgroundColour(couleurFond);
//        }
//        //si le systeme de couleurs est TSL
//        else if(systemeCouleur == 1)
//        {
//            //C1=teinte, C2=saturation, C3= luminance
//            Couleur *CouleurTSL = new Couleur(intervalle_lut[C7]->Coul.C1,
//                                                intervalle_lut[C7]->Coul.C2,
//                                                intervalle_lut[C7]->Coul.C3,
//                                                systemeCouleur);
//            CouleurTSL->TSL2RVB();
//            std::cout<<" Rtrans3  "<<CouleurTSL->C1<<std::endl;
//            std::cout<<"  Vtrans3  "<<CouleurTSL->C2<<std::endl;
//            std::cout<<" B trans3  "<<CouleurTSL->C3<<std::endl;
//            wxColour couleurFond((unsigned char)CouleurTSL->C1,
//                                    (unsigned char)CouleurTSL->C2,
//                                    (unsigned char)CouleurTSL->C3);
//            bouton[C7]->SetBackgroundColour(couleurFond);
//        }
//        bouton[C7]->Refresh();
//        wxString valeurBorne;
//        valeurBorne << intervalle_lut[C7]->b;
//        zonetexte[C7]->SetValue(valeurBorne);
//    }
//}

/*--------------------------------------------------------------------------*/
/* Permet de choisir le systême dans lequel seront définies les couleurs    */
/*--------------------------------------------------------------------------*/
/* Description : en entrée : choix d'une valeur dans la combobox            */
/*               en sortie : le systême choisi                              */
/* Explications : si RVB : systemeCouleur = 0                               */
/*                si TSL : systemeCouleur = 1                               */
/*--------------------------------------------------------------------------*/
//void MyFrame::ChoixSyst(wxCommandEvent& event)
//{
//    bool test = VerifSystCouleur();
//    std::cout<<"test systcoul  "<<test<<std::endl;
//    if(choixSystemeCouleur->GetSelection() == 0)
//    {
//        //if(VerifSystCouleur())
//        systemeCouleur = 0;
//    }
//    else
//    {
//        //VerifSystCouleur();
//        systemeCouleur = 1;
//    }
//    if(VerifSystCouleur())
//    {
///*		if(choixSystemeCouleur->GetSelection() == 0)
//        {
//            //if(VerifSystCouleur())
//            systemeCouleur = 0;
//        }
//        else
//        {
//            //VerifSystCouleur();
//            systemeCouleur = 1;
//        }*/
//    }
//    else
//    {
//        wxMessageBox(_T("Vous ne pouvez pas changer de systême de couleur
//                       après avoir défini une couleur"),
//                _T("About"), wxOK | wxICON_INFORMATION, this);
//        for (int C22 = 0; C22 <intervalle_lut.size();C22++)
//        {
//            intervalle_lut[C22]->modifier_coul(0,0,0,systemeCouleur);
//        }
//        wxColour CouleurBouton((unsigned char)0,
//                                (unsigned char)0,
//                                (unsigned char)0);
//        for (int C23 = 0; C23 <bouton.size();C23++)
//        {
//            bouton[C23]->SetBackgroundColour(CouleurBouton);
//            bouton[C23]->Refresh();
//        }
//    }
//}


//bool MyFrame::VerifSystCouleur()
//{
//    std::cout<<"test verif syst coul"<<std::endl;
//    bool modifSystCoul = false;
//    int nbrepassage = 0;
//    int C21;
//    C21 = 0;
//    if(intervalle_lut.size() == 0)
//    {
//        modifSystCoul = true;
//    }
//    else
//    {
//        while((intervalle_lut[C21]->Coul.C1 == 0) &&
//              (intervalle_lut[C21]->Coul.C2 == 0) &&
//              (intervalle_lut[C21]->Coul.C3 == 0))
//        {
//            C21 = C21+1;
//            std::cout<<"nbre passage  "<<nbrepassage<<std::endl;
//            nbrepassage =nbrepassage + 1;
//        }
//        if(nbrepassage == intervalle_lut.size())
//        {
//            modifSystCoul == true;
//        }
//        else
//        {
//            modifSystCoul == false;
//        }
//    }
//    return modifSystCoul;
//}

/*---------------------------------------------------------------------------*/
/*  Permet de choisir l'interpolation qui sera associée à la LUT             */
/*---------------------------------------------------------------------------*/
/* Description : en entrée : choix d'une valeur dans la combobox             */
/*               en sortie : le type d'interpolation choisi                  */
/* Explications : si interpolation exacte : typeInterpolation = 0            */
/*               si interpolation linéaire : typeInterpolation = 1           */
/*---------------------------------------------------------------------------*/
//void MyFrame::ChoixInterp(wxCommandEvent& event)
//{
//    if(choixInterpolation->GetSelection() == 0)
//    {
//        typeInterpolation = 0;
//        std::cout<<" interpolation exacte"<<std::endl;
//    }
//    else if (choixInterpolation->GetSelection() == 1)
//    {
//        typeInterpolation = 1;
//        std::cout<<"interpolation lineaire"<<std::endl;
//    }
//}

/*---------------------------------------------------------------------------*/
/*               Permet de saisir la borne minimale des attributs            */
/*---------------------------------------------------------------------------*/
/* Description : en entrée : saisie de la borne minimale                     */
/*               en sortie : saisie stockée dans f_borneMin                  */
/* Explications : pour le calcul automatique des bornes,                     */
/*                l'utilisateur doit définir l'intervalle de l'attribut      */
/*               donc la borne minimale (entre autres)                       */
/*---------------------------------------------------------------------------*/
//void MyFrame::BorneMinValeur(wxCommandEvent& WXUNUSED(event))
//{
//    wxString st_borneMin=borneMinValeur->GetValue();
//    double f_borneMintemp;
//    if (st_borneMin.ToDouble(&f_borneMintemp))
//    {
//        f_borneMin=f_borneMintemp;
//
//    }
//    else{
//        std::cout<<"string to double error"<<std::endl;
//    }
//    //verifie si la borne saisie n'est pas plus grande que la borne maximale
//    //si c'est le cas inverse les 2 valeurs
//    VerifBorneMinMax();
//}

/*---------------------------------------------------------------------------*/
/*               Permet de saisir la borne maximale des attributs            */
/*---------------------------------------------------------------------------*/
/* Description : en entrée : saisie de la borne maximale                     */
/*              en sortie : saisie stockÃ©e dans f_borneMax                  */
/* Explications : pour le calcul automatique des bornes,                     */
/*               l'utilisateur doit dÃ©finir l'intervalle de l'attribut      */
/*               donc la borne maximale (entre autres)                       */
/*---------------------------------------------------------------------------*/
//void MyFrame::BorneMaxValeur(wxCommandEvent& WXUNUSED(event))
//{
//    wxString st_borneMax=borneMaxValeur->GetValue();
//    double f_borneMaxtemp;
//    if (st_borneMax.ToDouble(&f_borneMaxtemp))
//    {
//        f_borneMax=f_borneMaxtemp;
//
//    }
//    else{
//        std::cout<<"string to double error"<<std::endl;
//    }
//    //verifie si la borne saisie n'est pas plus petite que la borne minimale
//    //si c'est le cas inverse les 2 valeurs
//    VerifBorneMinMax();
//}

/*---------------------------------------------------------------------------*/
/*     Permet de choisir le nombre d'intervalles qui seront calculés         */
/*---------------------------------------------------------------------------*/
/* Description :  en entrée : choix du nombre d'intervalles                  */
/*               en sortie : choix stockée dans nbintervalle                 */
/* Explications : pour le calcul automatique des bornes,                     */
/*               l'utilisateur doit choisir le nombre d'intervalles          */
/*                qui seront calculés                                        */
/*---------------------------------------------------------------------------*/
//void MyFrame::ChoixNbIntervalle(wxCommandEvent& WXUNUSED(event))
//{
//    nbintervalle = choixNbIntervalle->GetSelection() + 1;
//}

/*---------------------------------------------------------------------------*/
/*     Permet de calculer automatiquement les bornes de la LUT               */
/*---------------------------------------------------------------------------*/
/* Description : en entrée : clic sur le bouton "calcul"                     */
/*               en sortie : borne calculées automatiquement                 */
/*                          et interface remplie                             */
/* Explications : pour le calcul: en entrée:                                 */
/*                                  *borne minimale                          */
/*                                  *borne maximale                          */
/*                                  *nombre d'intervalles à calculer         */
/*                             en sortie:                                    */
/*                               *définition de chaque borne                 */
/*                                à partir de la valeur de l'attribut calculé*/
/*                               *stockage de ces borne dans intervalle_lut  */
/*                               *remplissage des zones de texte             */
/*                                avec les valeurs des bornes                */
/*             l'utilisateur doit choisir le nombre d'intervalles            */
/*              qui seront calculés                                          */
/*---------------------------------------------------------------------------*/
//void MyFrame::Calcul(wxCommandEvent& WXUNUSED(event))
//{
//    ViderLigne();
//    ViderIntervalleLut();
//    CreateLigne(nbintervalle+1,	vert7,0);
//    double tailleIntervalle = (f_borneMax - f_borneMin)/nbintervalle;
//    for(int C9=0;C9<nbintervalle+1;C9++)
//    {
//        double valborne = tailleIntervalle*C9 + f_borneMin;
//        wxString st_valborne;
//        st_valborne << valborne;
//        zonetexte[C9]->SetValue(st_valborne);
//        Borne *B1 = new Borne(valborne);
//        intervalle_lut.push_back(B1);
//    }
//}

/*---------------------------------------------------------------------------*/
/*                      Permet de choisir la transparence                    */
/*---------------------------------------------------------------------------*/
/* Description : en entrée : choix de la transparence                        */
/*               en sortie : choix stockée dans alpha                        */
/*---------------------------------------------------------------------------*/
//void MyFrame::ChoixTranparence(wxCommandEvent& WXUNUSED(event))
//{
//    alpha = transparence->GetValue();
//    std::cout<<"transp test  "<<(int)alpha<<std::endl;
//    int alphappl = (int)alpha*2.55;
//    std::cout<<"verif alphappl "<<alphappl<<std::endl;
//    for (int C14 = 0; C14<256 ; C14++)
//    {
//        for(int y3 = 0;y3<60;y3++)
//        {
//            image->SetAlpha(C14,y3,alphappl);
//        }
//    }
//}

/*---------------------------------------------------------------------------*/
/*                                Annuler                                    */
/*---------------------------------------------------------------------------*/
/* Description :en entrée : clic sur annuler                                 */
/*             en sortie : ferme la fenetre sans enreigstrer quoi que ce soit*/
/*---------------------------------------------------------------------------*/
//void MyFrame::Annuler(wxCommandEvent& WXUNUSED(event))
//{
//    //fermer la fenêtre
//    std::cout<< "annuler" <<std::endl;
//    Close(TRUE);
//}

/*---------------------------------------------------------------------------*/
/*                            Enregistrer                                    */
/*---------------------------------------------------------------------------*/
/* Description : en entrée : clic sur enregistrer                            */
/*              en sortie : fichier enregistré au format xml                 */
/*                 - si il avait déjà  été enregistré                        */
/*                    il écrase le precedent fichier                         */
/*                 - si il n'avais pas été déjà  enreigstré,                 */
/*                     bascule sur la fonction enregistrer                   */
/*---------------------------------------------------------------------------*/
//void MyFrame::Enregistrer(wxCommandEvent& WXUNUSED(event))
//{
//    //fermer la fenêtre
//    std::cout<< "enregistrer" <<std::endl;
//}

/*void MyFrame::EnregistrerSous(wxCommandEvent& WXUNUSED(event))
{
    //fermer la fenêtre
    std::cout<< "enregistrer sous" <<std::endl;
}*/

/*---------------------------------------------------------------------------*/
/*    Visualiser le résultat de la lut appliquée sur un nuage de points      */
/*---------------------------------------------------------------------------*/
/* Description : en entrée :clic sur "visualiser lut"                        */
/*               en sortie :ouvre la boite de dialogue permettant de choisir */
/*                     *le fichier de points à ouvrir                        */
/*                     *l'attribut sur lequel sera appliquée la lut          */
/*---------------------------------------------------------------------------*/
//void MyFrame::VisualiserLut(wxCommandEvent& event)
//{
//    if(typeInterpolation == -1)
//    {
//        wxMessageBox(_T("Il faut choisir le type d'interpolation"),
//                _T("About"), wxOK | wxICON_INFORMATION, this);
//    }
//    else if(intervalle_lut.size() <1)
//    {
//        wxMessageBox(_T("Il faut au moins deux bornes pour pouvoir
//                         calculer l'interpolation"),
//                _T("About"), wxOK | wxICON_INFORMATION, this);
//    }
//    else
//    {
//        OpenAlsFileDialog *dialogVisu = new OpenAlsFileDialog(systemeCouleur,
//                                                typeInterpolation,
//                                                intervalle_lut,
//                                                this,
//                                               wxT("Visualisation de la LUT"),
//                                               wxPoint(100,100),
//                                                wxSize(250,250));
//        dialogVisu->Show(TRUE);
//    }
//}


/*---------------------------------------------------------------------------*/
/*                  Exporter une image                                       */
/*---------------------------------------------------------------------------*/
/* Description : en entrée : choisir exporter une image dans le menu         */
/*               en sortie : enregistrement d'une image, deux extensions:    */
/*                              - bmp                                        */
/*                              - png, pour enregistrer l'information        */
/*                                de transparence                            */
/*---------------------------------------------------------------------------*/
//void MyFrame::OnExportImage(wxCommandEvent& WXUNUSED(event))
//{
//    std::cout<<"export d'une image"<<std::endl;
//    //creation de l'image
//    ImageRemplissageCouleur();
//    //choix de la destination de l'export
//    wxString savefilename = wxFileSelector( wxT("Save Image"),
//                                            wxEmptyString,
//                                            wxEmptyString,
//                                            (const wxChar *)NULL,
//                                            wxT("BMP files (*.bmp)|*.bmp|")
//                                            wxT("PNG files (*.png)|*.png"),
//                                            wxFD_SAVE,
//                                            this);
//    if ( savefilename.empty() )
//        return;
//
//    wxString extension;
//    wxFileName::SplitPath(savefilename, NULL, NULL, &extension);
//
//    bool saved = false;
//    if ( extension == _T("bmp") )
//    {
//        saved = image->SaveFile(savefilename, wxBITMAP_TYPE_BMP);
//    }
//    else if ( extension == _T("png") )
//    {
//        image->SetOption(wxIMAGE_OPTION_PNG_FORMAT, wxPNG_TYPE_COLOUR);
//        saved = image->SaveFile(savefilename, wxBITMAP_TYPE_PNG);
//    }
//    if ( !saved )
//    {
//        image->SaveFile(savefilename);
//    }
//}
/*---------------------------------------------------------------------------*/
/*                Exporter un fichier lut                                    */
/*---------------------------------------------------------------------------*/
/* Description : en entrée : choisir exporter un fichier lut dans le menu    */
/*              en sortie : fichier enregistré au format xml                 */
/*                           à l'emplacement choisi par l'utilisateur        */
/*---------------------------------------------------------------------------*/
//void MyFrame::OnExportFichierLut(wxCommandEvent& event)
//{
//    std::cout<<"export d'une lut"<<std::endl;
//    //creation d'un nouveau document xml
//    TiXmlDocument doc;
//    //ecriture de l'en-tÃªte
//    TiXmlElement* msg;
//    TiXmlDeclaration* decl = new TiXmlDeclaration( "1.0", "", "" );
//    doc.LinkEndChild( decl );
//    //ecriture de <lut> lié avec </lut>
//    TiXmlElement * root = new TiXmlElement( "lut" );
//    doc.LinkEndChild( root );
//    if(typeInterpolation==0)
//    {
//        root->SetAttribute("typeInterpolation","Interpolation exacte");
//    }
//    else if (typeInterpolation == 1)
//    {
//        root->SetAttribute("typeInterpolation","Interpolation lineaire");
//    }
//    if(systemeCouleur==0)
//    {
//        root->SetAttribute("systemeCouleur","RVB");
//    }
//    else if (systemeCouleur == 1)
//    {
//        root->SetAttribute("systemeCouleur","TSL");
//    }
//    //ecriture des lignes contenant <borne valeur = "" Rouge = "" Vert = "" bleu = "" />
//    for(int C17 = 0;C17<intervalle_lut.size();C17++)
//    {
//        TiXmlElement * window;
//        window = new TiXmlElement( "Borne" );
//        root->LinkEndChild( window );
//        window->SetAttribute("valeur",intervalle_lut[C17]->b);
//        if(systemeCouleur==0)
//        {
//        window->SetAttribute("Rouge",intervalle_lut[C17]->Coul.C1);
//        window->SetAttribute("Vert", intervalle_lut[C17]->Coul.C2);
//        window->SetAttribute("Bleu", intervalle_lut[C17]->Coul.C3);
//        }
//        else if(systemeCouleur==1)
//        {
//            window->SetAttribute("Teinte",intervalle_lut[C17]->Coul.C1);
//            window->SetAttribute("Saturation", intervalle_lut[C17]->Coul.C2);
//            window->SetAttribute("Luminance", intervalle_lut[C17]->Coul.C3);
//        }
//    }
//
//    //choix de la destination de l'export
//    wxString savefilenamelut = wxFileSelector( wxT("Save Image"),
//            wxEmptyString,
//            wxEmptyString,
//            (const wxChar *)NULL,
//            wxT("LUT files (*.lut)|*.lut"),
//            wxFD_SAVE,
//            this);
//
//    if ( savefilenamelut.empty() )
//        return;
//
//    wxString extension;
//    wxFileName::SplitPath(savefilenamelut, NULL, NULL, &extension);
//    char str_savefilenamelut[1024];
//    strcpy(str_savefilenamelut, (const char*)savefilenamelut.mb_str(wxConvUTF8));
//    //const char* str_savefilenamelut =  savefilenamelut.mb_str();
//    std::cout<<"path  "<<str_savefilenamelut<<std::endl;
//    doc.SaveFile( str_savefilenamelut ); // enregistrement du fichier exporté
//    //doc.SaveFile( savefilenamelut ); // enregistrement du fichier exporté
//    std::cout<<"export reussi"<<std::endl;
//}

/*---------------------------------------------------------------------------*/
/*                          Import d'un fichier lut                          */
/*---------------------------------------------------------------------------*/
/* Description : en entrée : un fichier .xml                                 */
/*               en sortie : le chemin du fichier à importer                 */
/*                          appel de la fonction ImportLut                   */
/*---------------------------------------------------------------------------*/
//void MyFrame::OnImportFichierLut(wxCommandEvent& event)
//{
//    std::cout<<"import d'une lut"<<std::endl;
//    wxFileDialog dialog
//                 (this,
//                    _T("Testing open file dialog"),
//                    wxEmptyString,
//                    wxEmptyString,
//                    _T("XML files (*.xml)|*.xml"));
//    dialog.ShowModal();
//    wxString loadfilename = dialog.GetPath();
//    std::cout<<"path  "<<std::string(dialog.GetFilename().mb_str())<<std::endl;
//    ImportLut(loadfilename);
//}

/*---------------------------------------------------------------------------*/
/*                        Importer un fichier lut                            */
/*---------------------------------------------------------------------------*/
/* Description : en entrée : le fichier à importer                           */
/*              en sortie : la lecture du fichier xml: de noeud en noeud     */
/*---------------------------------------------------------------------------*/
//void MyFrame::ImportLut(wxString lfilename)
//{
//    //vider les données precedentes
//    intervalle_lut.clear();
//    //convertit le wxString en const char
//    char str_lfilename[1024];
//    strcpy(str_lfilename, (const char*)lfilename.mb_str(wxConvUTF8));
//    TiXmlDocument doc(str_lfilename);
//    if(!doc.LoadFile()){
//        std::cerr<< "erreur lors du chargement" << std::endl;
//        std::cerr << "error #" << doc.ErrorId() << " : " << doc.ErrorDesc()
//        << std::endl;
//    }
//    //lecture du fichier
//    TiXmlHandle hdl(&doc);
//    TiXmlElement* pElem;
//    pElem=hdl.FirstChild("lut").Element();
//    //parcourt les noeuds et enregistre les éléments
//    if (pElem)
//    {
//        std::cout<<"1 element"<<std::endl;
//        std::string typeInterpstring = pElem->Attribute("typeInterpolation");
//        std::string systCoulstring = pElem->Attribute("systemeCouleur");
//        std::cout<<systCoulstring<<std::endl;
//        if(typeInterpstring == "Interpolation exacte")
//        {
//            std::cout<<"entre dans inter exacte"<<std::endl;
//            typeInterpolation=0;
//        }
//        else if(typeInterpstring == "Interpolation lineaire")
//        {
//            std::cout<<"entre dans inter lineaire"<<std::endl;
//            typeInterpolation=1;
//        }
//        if(systCoulstring == "RVB")
//        {
//            std::cout<<"rvb"<<std::endl;
//            systemeCouleur=0;
//        }
//        else if(systCoulstring == "TSL")
//        {
//            std::cout<<"tsl"<<std::endl;
//            systemeCouleur=1;
//        }
//    }
//
//    TiXmlElement *elem = hdl.FirstChildElement().FirstChildElement().Element();
//    if(!elem){
//        std::cout << "le noeud Ã  atteindre n'existe pas" << std::endl;
//    }
//    while (elem){
//        std::string d1;
//        double nam;
//        d1 = elem->Attribute("valeur");
//        nam = atof(d1.c_str());
//        std::cout<<"verif double b "<<nam<<std::endl;
//        int rouge,bleu,vert;
//        if(systemeCouleur == 0)
//        {
//            elem->QueryIntAttribute("Rouge", &rouge);
//            elem->QueryIntAttribute("Vert", &vert);
//            elem->QueryIntAttribute("Bleu", &bleu);
//        }
//        else if (systemeCouleur == 1)
//        {
//            elem->QueryIntAttribute("Teinte", &rouge);
//            elem->QueryIntAttribute("Saturation", &vert);
//            elem->QueryIntAttribute("Luminance", &bleu);
//        }
//        elem = elem->NextSiblingElement(); // iteration
//        Borne *Btemp = new Borne(nam,rouge,vert,bleu,systemeCouleur);
//        intervalle_lut.push_back(Btemp);
//    }
//    //appelle les 2 fonctions permettant de remplir l'interface:
//    //les 2 combobox et le tableau avec les valeurs d'intervalle_lut
//    LutRemplirInterface(typeInterpolation,systemeCouleur);
//    LutRemplirTableau();
//}

/*---------------------------------------------------------------------------*/
/*          Remplir le tableau à partir des valeurs d'intervalle_lut         */
/*---------------------------------------------------------------------------*/
/* Description : en entrée : les infos contenues dans le fichier xml         */
/*                         (precedemment lu)                                 */
/*               en sortie : la lut de fichier affichée dans l'interface     */
/*                          les caractéristiques de la lut                   */
/*                                   stockées dans intervalle_lut            */
/*---------------------------------------------------------------------------*/
//void MyFrame::LutRemplirTableau()
//{
//    ViderLigne();
//    f_borneMin = 1000;
//    f_borneMax = -1000;
//    CreateLigne(intervalle_lut.size(),vert7,0);
//    for(int C16 = 0; C16<intervalle_lut.size();C16++)
//    {
//        wxString mavaleurborne;
//        mavaleurborne << intervalle_lut[C16]->b;
//        zonetexte[C16]->SetValue(mavaleurborne);
//        //std::cout<<"max  "<<f_borneMax<<std::endl;
//        //std::cout<<"min  "<<f_borneMin<<std::endl;
//        //std::cout<<intervalle_lut[C16]->b<<std::endl;
//        VerifBorneMin(intervalle_lut[C16]->b);
//        VerifBorneMax(intervalle_lut[C16]->b);
//        if(systemeCouleur == 0)
//        {
//        wxColour couleurBorne(intervalle_lut[C16]->Coul.C1,
//                intervalle_lut[C16]->Coul.C2,
//                intervalle_lut[C16]->Coul.C3,
//                wxALPHA_OPAQUE);
//        bouton[C16]->SetBackgroundColour(couleurBorne);
//        }
//        else if (systemeCouleur == 1)
//        {
//            Couleur *CouleurTSLImport = new Couleur(
//                                   intervalle_lut[C16]->Coul.C1,
//                                   intervalle_lut[C16]->Coul.C2,
//                                   intervalle_lut[C16]->Coul.C3,
//                                   systemeCouleur);
//            CouleurTSLImport->TSL2RVB();
//            int Couleur1 = CouleurTSLImport->C1;
//            int Couleur2 = CouleurTSLImport->C2;
//            int Couleur3 = CouleurTSLImport->C3;
//            wxColour couleurBorne(Couleur1,
//                                    Couleur2,
//                                    Couleur3,
//                    wxALPHA_OPAQUE);
//            bouton[C16]->SetBackgroundColour(couleurBorne);
//        }
//    }
//    MAJNbIntervalle();
//
//}

/*---------------------------------------------------------------------------*/
/*     Remplir les 2 combobox (choixInterpolation et choixSystemeCouleur)    */
/*          à partir des données contenues dans le fichier xml               */
/*---------------------------------------------------------------------------*/
//void MyFrame::LutRemplirInterface(int type, int syst)
//{
//    if(type == 0)
//    {
//        choixInterpolation->SetValue(_T("Interpolation exacte"));
//    }
//    else if(type == 1)
//    {
//        choixInterpolation->SetValue(_T("Interpolation lineaire"));
//    }
//    if(syst == 0)
//    {
//        choixSystemeCouleur->SetValue(_T("RVB"));
//    }
//    else if(syst == 1)
//    {
//        choixSystemeCouleur->SetValue(_T("TSL"));
//    }
//}

/*--------------------------------------------------------------------------*/
/*     Controle si la bornemin est bien inférieure à la bornemax            */
/*          échange les deux bornes si ce n'est pas le cas                  */
/*--------------------------------------------------------------------------*/
//void MyFrame::VerifBorneMinMax()
//{
//    if((f_borneMin != 1000)&& (f_borneMax != -1000))
//    {
//        if(f_borneMin > f_borneMax)
//        {
//            double Btemp = f_borneMin;
//            f_borneMin = f_borneMax;
//            f_borneMax = Btemp;
//            wxString str_borneMax;
//            str_borneMax << f_borneMax;
//            wxString str_borneMin;
//            str_borneMin << f_borneMin;
//            borneMaxValeur->SetValue(str_borneMax);
//            borneMinValeur->SetValue(str_borneMin);
//        }
//    }
//}

/*--------------------------------------------------------------------------*/
/* Lors de la saisie, contrôle si la borne saisie est supérieure            */
/*                     à la borne max                                       */
/*    remplace la bornemax par la nouvelle valeur dans ce cas               */
/*--------------------------------------------------------------------------*/
//void MyFrame::VerifBorneMax(double val)
//{
//    if(val>f_borneMax)
//    {
//        f_borneMax = val;
//        wxString str_bMax;
//        str_bMax << f_borneMax;
//        borneMaxValeur->SetValue(str_bMax);
//    }
//}

/*---------------------------------------------------------------------------*/
/*  Lors de la saisie, contrôle si la borne saisie est inférieure            */
/*                         à la borne min                                    */
/*      remplace la bornemin par la nouvelle valeur dans ce cas              */
/*---------------------------------------------------------------------------*/
//void MyFrame::VerifBorneMin(double valm)
//{
//    if(valm<f_borneMin)
//    {
//        f_borneMin = valm;
//        wxString str_bMin;
//        str_bMin << f_borneMin;
//        borneMinValeur->SetValue(str_bMin);
//    }
//}




